package io.renren.utils;

import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * HTTP 请求工具类
 *
 * @author : liii
 * @version : 1.0.0
 * @date : 2015/7/21
 * @see : TODO
 */
public class HttpClientUtils {

        private static PoolingHttpClientConnectionManager connMgr;
        private static RequestConfig requestConfig;
        private static final int MAX_TIMEOUT = 50000;

        static {
            // 设置连接池
            connMgr = new PoolingHttpClientConnectionManager();
            // 设置连接池大小
            connMgr.setMaxTotal(100);
            connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());

            RequestConfig.Builder configBuilder = RequestConfig.custom();
            // 设置连接超时
            configBuilder.setConnectTimeout(MAX_TIMEOUT);
            // 设置读取超时
            configBuilder.setSocketTimeout(MAX_TIMEOUT);
            // 设置从连接池获取连接实例的超时
            configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);
            // 在提交请求之前 测试连接是否可用
            configBuilder.setStaleConnectionCheckEnabled(true);
            requestConfig = configBuilder.build();
        }

        /**
         * 发送 GET 请求（HTTP），不带输入数据
         * @param url
         * @return
         */
        public static String doGet(String url) {
            return doGet(url, new HashMap<String, Object>());
        }

        /**
         * 发送 GET 请求（HTTP），K-V形式
         * @param url
         * @param params
         * @return
         */
        public static String doGet(String url, Map<String, Object> params) {
            String apiUrl = url;
            StringBuffer param = new StringBuffer();
            int i = 0;
            for (String key : params.keySet()) {
                if (i == 0)
                    param.append("?");
                else
                    param.append("&");
                param.append(key).append("=").append(params.get(key));
                i++;
            }
            apiUrl += param;
            String result = null;
            CloseableHttpClient httpClient = HttpClients.createDefault();
            try {
                HttpGet httpGet = new HttpGet(apiUrl);
                CloseableHttpResponse response = httpClient.execute(httpGet);
                int statusCode = response.getStatusLine().getStatusCode();

                System.out.println("执行状态码 : " + statusCode);

                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    InputStream inStream = entity.getContent();
                    result = IOUtils.toString(inStream, "UTF-8");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("result:"+result);
            return result;
        }

        /**
         * 发送 POST 请求（HTTP），不带输入数据
         * @param apiUrl
         * @return
         * @throws Exception 
         */
        public static String doPost(String apiUrl) throws Exception {
            return doPost(apiUrl, new HashMap<String, Object>());
        }

        /**
         * 发送 POST 请求（HTTP），K-V形式
         * @param apiUrl API接口URL
         * @param params 参数map
         * @return
         * @throws Exception 
         */
        public static String doPost(String apiUrl, Map<String, Object> params) throws Exception {
            CloseableHttpClient httpClient = HttpClients.createDefault();
            String httpStr = null;
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;

            try {
                httpPost.setConfig(requestConfig);
                List<NameValuePair> pairList = new ArrayList<>(params.size());
                for (Map.Entry<String, Object> entry : params.entrySet()) {
                    NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                            .getValue().toString());
                    pairList.add(pair);
                }
                httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
                response = httpClient.execute(httpPost);
                if(response!=null){
                System.out.println(response.toString());
                }
                HttpEntity entity = response.getEntity();
                httpStr = EntityUtils.toString(entity, "UTF-8");
            } catch (IOException e) {
                e.printStackTrace();
                throw new Exception();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                        int statusCode = response.getStatusLine().getStatusCode();
                        System.out.println("返回状态码 : " + statusCode);
                        if(statusCode!=200){
                        	throw new Exception();
                        } 
                    } catch (IOException e) {
                        e.printStackTrace();
                        throw new Exception();
                    }
                }
            }
            
            System.out.println("httpStr:"+httpStr);
            return httpStr;
        }

        /**
         * 发送 POST 请求（HTTP），JSON形式
         * @param apiUrl
         * @param json json对象
         * @return
         */
        public static String doPost(String apiUrl, Object json) {
            CloseableHttpClient httpClient = HttpClients.createDefault();
            String httpStr = null;
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;

            try {
                httpPost.setConfig(requestConfig);
                StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
                stringEntity.setContentEncoding("UTF-8");
                stringEntity.setContentType("application/json");
                httpPost.setEntity(stringEntity);
                response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                System.out.println(response.getStatusLine().getStatusCode());
                httpStr = EntityUtils.toString(entity, "UTF-8");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("httpStr:"+httpStr);
            return httpStr;
        }

        /**
         * 发送 SSL POST 请求（HTTPS），K-V形式
         * @param apiUrl API接口URL
         * @param params 参数map
         * @return
         */
        public static String doPostSSL(String apiUrl, Map<String, Object> params) {
            CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
            String httpStr = null;

            try {
                httpPost.setConfig(requestConfig);
                List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
                for (Map.Entry<String, Object> entry : params.entrySet()) {
                    NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                            .getValue().toString());
                    pairList.add(pair);
                }
                httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("utf-8")));
                response = httpClient.execute(httpPost);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    return null;
                }
                HttpEntity entity = response.getEntity();
                if (entity == null) {
                    return null;
                }
                httpStr = EntityUtils.toString(entity, "utf-8");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }

        /**
         * 发送 SSL POST 请求（HTTPS），JSON形式
         * @param apiUrl API接口URL
         * @param json JSON对象
         * @return
         */
        public static String doPostSSL(String apiUrl, Object json) {
            CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
            String httpStr = null;

            try {
                httpPost.setConfig(requestConfig);
                StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
                stringEntity.setContentEncoding("UTF-8");
                stringEntity.setContentType("application/json");
                httpPost.setEntity(stringEntity);
                response = httpClient.execute(httpPost);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    return null;
                }
                HttpEntity entity = response.getEntity();
                if (entity == null) {
                    return null;
                }
                httpStr = EntityUtils.toString(entity, "utf-8");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }

        /**
         * 创建SSL安全连接
         *
         * @return
         */
        private static SSLConnectionSocketFactory createSSLConnSocketFactory() {
            SSLConnectionSocketFactory sslsf = null;
            try {
                SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {

                    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                        return true;
                    }
                }).build();
                sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

                    @Override
                    public boolean verify(String arg0, SSLSession arg1) {
                        return true;
                    }

                    @Override
                    public void verify(String host, SSLSocket ssl) throws IOException {
                    }

                    @Override
                    public void verify(String host, X509Certificate cert) throws SSLException {
                    }

                    @Override
                    public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
                    }
                });
            } catch (GeneralSecurityException e) {
                e.printStackTrace();
            }
            return sslsf;
        }


        /**
         * 测试方法
         * @param args
         */
        public static void main(String[] args) throws Exception {
		try {
			Map<String, Object> params = new HashMap<String, Object>();

			String key = Global.getConfig("b1key");// 获取key
			String url = Global.getConfig("b1url1");// 获取url
			
			url = "http://b1.hansap.com/huashun/external/resetStatus";//b1重置所有数据
			
			System.out.println("key:" + key);
			System.out.println("url:" + url);

			// params.put("cardCode", "A001");
			params.put("sfjsd", "1");
			String sign = Sha1Util.SHA1(params, key);// 计算签名
			System.out.println("sign:" + sign);
			params.put("sign", sign);
			String result = HttpClientUtils.doPost(url, params);// 发送请求
			//System.out.println("result:" + result);
			if (result != null) {
				Map<String, Object> b1Map = new HashMap<String, Object>();
				b1Map = FastJsonUtils.stringToCollect(result);
				if (b1Map != null && b1Map.size() > 0) {
					if (b1Map.get("isSuc") != null && (b1Map.get("isSuc").equals("y"))) {
							//System.out.println("b1map.size():"+b1Map.size());
						System.out.println(b1Map.get("data").getClass().getName());
						System.out.println(b1Map.get("data"));
						List<HashMap> dataList = FastJsonUtils.toList(String.valueOf(b1Map.get("data")), HashMap.class);
						//System.out.println("dataList.size:"+dataList.size());
						for(HashMap tMap:dataList){
							
						}
					} else {
						throw new Exception();
					}
				}
			} else {
				throw new Exception();
			}
		} catch (Exception e) {
					System.out.println("与b1数据同步发生异常！");
					e.printStackTrace();
				}        	
        }
        	
        	
}
